#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <signal.h>
#include <fcntl.h>
#include "pilasColasListas.h"

/*------------- Liberar Memoria De toda una Estructura De Datos --------*/
int destruir(Tnodo** estructura){
Tnodo* estruct;
Tnodo* aux;
estruct=(*estructura);

while(estruct!=NULL){
	aux=estruct;
	estruct=(*aux).next;
	free(aux);
	}
return 1;
}



/*----------- Inicializar Estructura De Datos -----------*/

int inicializar(Tnodo **estructura){
	(*estructura)=NULL;
	return 1;
}

/*--------------Cambiar Una Cola Por Una Pila-------------*/

int colaToPila(Tnodo**cola){

Tnodo *pila;
Tnodo *auxPuntero;

inicializar(&pila);

if(popEnPila(cola,&auxPuntero)==-1) auxPuntero=NULL;
while(auxPuntero){
	pushEnPila(&pila,&auxPuntero);
        if(popEnPila(cola,&auxPuntero)==-1) auxPuntero=NULL;
   }
(*cola)=pila;
return 1;
}

/*---------------Cambiar Una Pila Por Una Cola ---------*/

int pilaToCola(Tnodo**pila){
Tnodo* cola;
Tnodo* auxPuntero;

inicializar(&cola);
if(popEnPila(pila,&auxPuntero)==-1) auxPuntero=NULL;
while(auxPuntero){
	pushEnPila(&cola,&auxPuntero);
	if(popEnPila(pila,&auxPuntero)==-1) auxPuntero=NULL;
    }
(*pila)=cola;
return 1;
}

/*---------Cambiar Una Pila por una Lista Ordenada------*/

int pilaToLista(Tnodo**pila){

Tnodo*lista;
Tnodo* auxPuntero;
inicializar(&lista);
if(popEnPila(pila,&auxPuntero)==-1) auxPuntero=NULL;
while(auxPuntero){
   insertarEnLista(&lista,&auxPuntero);
   if(popEnPila(pila,&auxPuntero)==-1) auxPuntero=NULL;
   }
(*pila)=lista;
return 1;
}

/*-------Cambiar Una Cola por Una Lista Ordenada-------*/

int colaToLista(Tnodo**cola){

Tnodo*lista;
Tnodo* auxPuntero;

inicializar(&lista);
if(popEnPila(cola,&auxPuntero)==-1) auxPuntero=NULL;
while(auxPuntero){
   insertarEnLista(&lista,&auxPuntero);
   if(popEnPila(cola,&auxPuntero)==-1) auxPuntero=NULL;
   }
(*cola)=lista;
return 1;
}
/*---------Cambiar Una Pila por una Lista Ordenada Decreciente------*/

int pilaToListaDec(Tnodo**pila){

Tnodo*lista;
Tnodo* auxPuntero;
inicializar(&lista);
if(popEnPila(pila,&auxPuntero)==-1) auxPuntero=NULL;
while(auxPuntero){
   insertarEnListaDec(&lista,&auxPuntero);
   if(popEnPila(pila,&auxPuntero)==-1) auxPuntero=NULL;
   }
(*pila)=lista;
return 1;
}

/*-------Cambiar Una Cola por Una Lista Ordenada Decreciente-------*/

int colaToListaDec(Tnodo**cola){

Tnodo*lista;
Tnodo* auxPuntero;

inicializar(&lista);
if(popEnPila(cola,&auxPuntero)==-1) auxPuntero=NULL;
while(auxPuntero){
   insertarEnListaDec(&lista,&auxPuntero);
   if(popEnPila(cola,&auxPuntero)==-1) auxPuntero=NULL;
   }
(*cola)=lista;
return 1;
}
/*----------------Push En Pila------------------------*/
int pushEnPila(Tnodo**pila,Tnodo** nodo){

(**nodo).next=(*pila);
(*pila)=(*nodo);
return 1;
}



/*----------------- Pop en Pila----------------------*/
/*--------------Recordar Liberar Memoria--------*/

int popEnPila(Tnodo**pila,Tnodo**nodo){
Tnodo *aux;

if(*pila==NULL)	return -1;

aux=*pila;
(*nodo)=*pila;
(*pila)=(*aux).next;

return 1;
}



/*-------------Push en cola---------------------*/

int pushEnCola(Tnodo**cola,Tnodo**nodo){

Tnodo* aux;
aux=(*cola);
(*nodo)->next=NULL;

if(*cola==NULL) {
	*cola=*nodo;
	return 1;
   }
while(((*aux).next)!=NULL) {
	aux=(*aux).next;
	}
	
(*aux).next=*nodo;
return 1;
}

/*----------Pop en Cola-----------------------*/
/*-------Recordar Liberar Memoria -----------*/

int popEnCola(Tnodo**cola,Tnodo**nodo){

if((*cola)==NULL) return -1;
*nodo=*cola;
*cola=(**cola).next;
return 1;
}

/*--------------------CREAR NODO NUEVO ------------------------------*/

int crearNodo(Tnodo** nodo,int tamanioNodo){

	if((*nodo=(Tnodo*)malloc(tamanioNodo))==NULL)return 0;

(**nodo).next=NULL;
return 1;
}



/*------------CARGAR NODO (Personal)---------------------*/
/*Debe Realizarse para nuestros Datos---------*
*-------------------------------------------------------*/


/*----------------------- INSERTARNODO EN LA LISTA -----------------------*/
int insertarEnLista(Tnodo **lista,Tnodo** nodo) {

Tnodo* auxnodo;

/*if((*lista==NULL) || (strcmp((**lista).clave,(**nodo).clave)>0))*/
if((*lista==NULL) || (**lista).clave>(**nodo).clave)

	{
	(**nodo).next=*lista;
	*lista=*nodo;
	return 1;
	}

else{
	auxnodo=*lista;
	while((*auxnodo).next!=NULL  &&
   /*(strcmp(auxnodo->next->clave,(*nodo)->clave)<0))*/
     (auxnodo->next->clave)<((*nodo)->clave))

    
	auxnodo=(*auxnodo).next;

	(**nodo).next=(*auxnodo).next;
	(*auxnodo).next=*nodo;
	return 1;
}

}
/*----------------------- INSERTARNODO EN LA LISTA -----------------------*/
int insertarEnListaDec(Tnodo **lista,Tnodo** nodo) {

Tnodo* auxnodo;

/*if((*lista==NULL) || (strcmp((**lista).clave,(**nodo).clave)>0))*/
if((*lista==NULL) || (**lista).clave<(**nodo).clave)

	{
	(**nodo).next=*lista;
	*lista=*nodo;
	return 1;
	}

else{
	auxnodo=*lista;
	while((*auxnodo).next!=NULL  &&
   /*(strcmp(auxnodo->next->clave,(*nodo)->clave)<0))*/
     (auxnodo->next->clave)>((*nodo)->clave))

    
	auxnodo=(*auxnodo).next;

	(**nodo).next=(*auxnodo).next;
	(*auxnodo).next=*nodo;
	return 1;
}

}

/*--------------------------ELIMINAR NODO------------------------------*/
/* Si no lo encontro o esta vacia devuelve 0, si no un valor distinto de 0*/

int eliminarNodo(Tnodo** lista,Tnodo** nodo){

	Tnodo* listaAux;

	listaAux = *lista;
	/*Si esta vacia devolvemos 0*/	
	if((listaAux)==NULL) return 0;
	
	/*Si esta en el primer nodo */
	if((listaAux)==*nodo){
		*lista=(**nodo).next;
		free(*nodo);
		return 1;
	}

/*Si solo tiene 1 Nodo*/
if((*listaAux).next==NULL){ 
if(listaAux==(*nodo)){
free(*lista);
*lista=NULL;	
return 1;
}
return 0; /*No esta ese nodo*/
}

/*tiene 2 Nodos*/
if(listaAux->next->next==NULL){

/*vemos si es el primero*/
if(listaAux==(*nodo)){
	*lista=(**lista).next;	
	free(*nodo);
	return 1;
}
/*vemos si es el segundo*/
if((*listaAux).next==(*nodo)){
	free(*nodo);
	(**lista).next=NULL;
	return 2;
}
}	


/*Si tiene 3 o mas nodos*/
while((listaAux->next->next)!=NULL){

	if((*listaAux).next==*nodo){
		(*listaAux).next=(**nodo).next;
     		free(*nodo);
         	return 3;}
   
	
  listaAux=(*listaAux).next;
}
/* me queda el ultimo o el anteultimo*/
if(listaAux->next->next==NULL){

/*vemos si es el anteultimo*/
if(listaAux==(*nodo)){
	(*listaAux).next=(**nodo).next;
	free(*nodo);
	return 9;
}
/*vemos si es el ultimo*/
if((*listaAux).next==(*nodo)){
	free(*nodo);
	(*listaAux).next=NULL;
	return 10;
}
}
return 0;
}

/*--------------------- BUSCAR NODO --------------------------*/
int buscarNodo(Tnodo** lista, int clave,Tnodo** encontrado)
{

Tnodo *auxnodo;
auxnodo=*lista;

if(*lista==NULL) return 0;

if((*auxnodo).clave==clave)
	{
	*encontrado=auxnodo;
	return 1;
	}


while((*auxnodo).next!=NULL){
  	if( auxnodo->next->clave==clave){
	  	*encontrado=(*auxnodo).next;
	  	return 1;
  		}
	auxnodo=(*auxnodo).next;
}


*encontrado=NULL;
return 0;
}

/*--------------------- BUSCAR NODO --------------------------*/
int sizeofList(Tnodo** lista) {

	int i = 0;
	Tnodo *auxnodo;
	
	auxnodo = *lista;
	
	/* printf("1 so\n"); */
	if(auxnodo == NULL) {
		return 0;
	}

	/* printf("2 so\n"); */
	
	while(auxnodo != NULL){
	  	/* printf(" A \n"); */
	  	i++;
	  	
	  	/*
	  	printf(" B \n");
	  	printf (" %d \n ", auxnodo);
	  	printf (" %d \n ", (*auxnodo).next);
		*/
		auxnodo=(*auxnodo).next;

		/* printf(" C \n"); */
	}
	return i;
}
